home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / asyncstg / barrobj.h < prev    next >
C/C++ Source or Header  |  1995-12-05  |  5KB  |  145 lines
  1. #ifndef _BYTEARRAYWRAPPER_INCLUDE
  2. #define _BYTEARRAYWRAPPER_INCLUDE
  3.  
  4. #include <ole2.h>
  5. #include <olectl.h>
  6. #include "asyncstg.h"
  7. #include "bytearr.h"
  8.  
  9. class CAsyncByteArrayFactory;
  10. class CLockBytesConnectionPoint;
  11. //class CFillLockBytesConnectionPoint;
  12. //class CBindStatusCallbackConnectionPoint;
  13.  
  14. class CAsyncByteArray : public ILockBytes, public IFillLockBytes, public IConnectionPointContainer
  15. {
  16. public:
  17.     // IUnknown methods
  18.     HRESULT _stdcall QueryInterface(REFIID riid, void** ppObject);
  19.     ULONG    _stdcall AddRef();
  20.     ULONG    _stdcall Release();
  21.  
  22.     // ILockBytes methods
  23.     HRESULT __stdcall ReadAt(ULARGE_INTEGER ulOffset,void *pv, ULONG cb, ULONG *pcbRead);
  24.     HRESULT __stdcall WriteAt(ULARGE_INTEGER ulOffset,const void *pv, ULONG cb, ULONG *pcbWritten);
  25.     HRESULT __stdcall Flush( void);
  26.     HRESULT __stdcall SetSize(ULARGE_INTEGER cb);
  27.     HRESULT __stdcall LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
  28.     HRESULT __stdcall UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
  29.     HRESULT __stdcall Stat(STATSTG *pstatstg, DWORD grfStatFlag);
  30.     
  31.     // IFillLockBytes methods
  32.     HRESULT __stdcall SetFillSize(ULARGE_INTEGER cb);
  33.     HRESULT __stdcall FillAppend(void const *pv, ULONG cb, ULONG *pcbWritten);
  34.     HRESULT __stdcall FillAt(ULARGE_INTEGER ulOffset, void const *pv, ULONG cb, ULONG *pcbWritten);
  35.     HRESULT __stdcall Terminate(DWORD dwStatus);
  36.  
  37.     // IConnectionPointContainer methods
  38.     HRESULT __stdcall EnumConnectionPoints(LPENUMCONNECTIONPOINTS FAR* ppEnum);
  39.     HRESULT __stdcall FindConnectionPoint(REFIID iid, LPCONNECTIONPOINT FAR* ppCP);
  40.  
  41.     friend CAsyncByteArrayFactory;
  42.     friend CLockBytesConnectionPoint;
  43. private:
  44.  
  45.     CAsyncByteArray();
  46.     HRESULT Initialize(IUnknown* punkOuter);
  47.     ~CAsyncByteArray();
  48.  
  49.     #define FILLINFOINITSIZE (10)
  50.     #define FILLINFOREALLOCSIZE (10)
  51.  
  52.     class CInnerUnk : public IUnknown 
  53.     {
  54.     public:
  55.         // IUnknown methods
  56.         HRESULT _stdcall QueryInterface(REFIID riid, void** ppObject);
  57.         ULONG    _stdcall AddRef();
  58.         ULONG    _stdcall Release();
  59.  
  60.         CInnerUnk(CAsyncByteArray* pObj);
  61.  
  62.         CAsyncByteArray* m_pObj;
  63.     } *m_punkInner;
  64.     friend CInnerUnk;
  65.  
  66.     IUnknown* m_punkOuter;
  67.     ULONG m_dwRefCount;
  68.  
  69.     CRITICAL_SECTION m_sectLBConnect; // protects m_pCacheArray/m_pDataArray pointer manipulations
  70.     ILockBytes* m_pCacheArray;    // Cache Byte Array
  71.     ILockBytes* m_pDataArray;        // optional Data Byte Array
  72.     CLockBytesConnectionPoint* m_pLBConnect;
  73.     //CFillLockBytesConnectionPoint* pFillLBConnect;
  74.     //CBindStatusCallbackConnectionPoint* pBSCConnect;
  75.  
  76.     
  77.     // Access to FILLINFO etc is guarded with the following:
  78.     CRITICAL_SECTION m_sectNewReadAllowed;    // Indicates if new read access can be obtained, has to be release immediately
  79.     DWORD  m_nReadsPending;            // number of outstanding reads
  80.     HANDLE m_hevntNoReadsPending;    // m_nReadsPending has reached 0
  81.  
  82.     // To obtain read access: READFILLINFOLOCK
  83.     // To release read access: READFILLINFOUNLOCK 
  84.     // To obtain exclusive write access: WRITEFILLINFOLOCK
  85.     // To relase exclusive write access: WRITEFILLINFOUNLOCK
  86.  
  87.     // Deadlock: May not use WRITEFILLINFOLOCK with a pending READFILLINFOLOCK in the same thread
  88.  
  89.     // FILLINFO describes a valid block of data within the Cache Byte Array
  90.     typedef struct _tagFillInfo 
  91.     {
  92.         DWORDLONG    ulOffset;
  93.         DWORDLONG    cb;
  94.     } FILLINFO;
  95.     FILLINFO*        m_pFillInfo; // An array of FILLINFO structs
  96.  
  97.     DWORD            m_nFillInfo; // number of FILLINFO structs in m_pFillInfo
  98.     DWORD            m_nFillAlloc; // number of allocated FILLINFO structs
  99.     DWORDLONG        m_ulFillSize; // 0 indicates not set!
  100.     HANDLE            m_hevntNewFillInfo; // Pulsed when FillInfo should be reinterpreted
  101.  
  102.     BOOL            m_bTerminated; // used to decide if to return STG_E_PENDING or E_FAIL
  103.     BOOL            m_bBlocking;
  104. };
  105.  
  106. extern ULONG g_dwRefCount;
  107.  
  108.     // To obtain read access:
  109. #define READFILLINFOLOCK \
  110.     { \
  111.         EnterCriticalSection(&m_sectNewReadAllowed); \
  112.         InterlockedIncrement((LPLONG) &m_nReadsPending); \
  113.         if (!ResetEvent(m_hevntNoReadsPending)) \
  114.         { \
  115.             \
  116.         } \
  117.         LeaveCriticalSection(&m_sectNewReadAllowed); \
  118.     }
  119.     // To release read access:
  120. #define READFILLINFOUNLOCK \
  121.     { \
  122.         if (!InterlockedDecrement((LPLONG) &m_nReadsPending)) \
  123.         { \
  124.             if (!SetEvent(m_hevntNoReadsPending)) \
  125.             { \
  126.                 \
  127.             } \
  128.         } \
  129.     }
  130.     // To obtain exclusive write access:
  131. #define WRITEFILLINFOLOCK \
  132.     { \
  133.         WaitForSingleObject(m_hevntNoReadsPending, INFINITE); \
  134.         EnterCriticalSection(&m_sectNewReadAllowed); \
  135.         WaitForSingleObject(m_hevntNoReadsPending, INFINITE); \
  136.     }
  137.  
  138.     // To relase exclusive write access:
  139. #define WRITEFILLINFOUNLOCK \
  140.     { \
  141.         LeaveCriticalSection(&m_sectNewReadAllowed); \
  142.     }
  143.  
  144. #endif
  145.